home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 3 / ct-rom iiib.zip / ct-rom iiib / WINDOWS / DIVERSEN / WINE02BX / ILISP < prev    next >
Text File  |  1993-03-28  |  70KB  |  1,769 lines
  1. Info file ilisp.info, produced by Makeinfo, -*- Text -*- from input
  2. file ilisp.texi.
  3.  
  4.    This file documents ILISP.
  5.  
  6.    This is edition 0.9 of the ILISP manual for ILISP Version 4.11.
  7.  
  8.    Copyright (C) 1991 Todd Kaufmann
  9.  
  10.    Permission is granted to make and distribute verbatim copies of
  11. this manual provided the copyright notice and this permission notice
  12. are preserved on all copies.
  13.  
  14.    Permission is granted to copy and distribute modified versions of
  15. this manual under the conditions for verbatim copying, provided that
  16. the entire resulting derived work is distributed under the terms of
  17. a permission notice identical to this one.
  18.  
  19.    Permission is granted to copy and distribute translations of this
  20. manual into another language, under the above conditions for
  21. modified versions, except that this permission notice may be stated
  22. in a translation approved by the Foundation.
  23.  
  24. 
  25. File: ilisp.info,  Node: Top,  Next: Distribution,  Prev: (dir),  Up: (dir)
  26.  
  27.    This Info file documents ILISP, a GNU Emacs interface for a lisp
  28. running in a buffer.
  29.  
  30. * Menu:
  31.  
  32. * Distribution::        How to get the latest ILISP distribution.
  33.  
  34. * Acknowledgements::        Acknowledgements
  35. * Introduction::        An introduction to ILISP and its features.
  36. * Installation::        How to install ILISP.
  37. * Starting up::            How to run a Lisp process using ILISP.
  38.  
  39. * Buffers of ILISP::        Buffers used by ILISP, and their commands.
  40. * ILISP Commands::        
  41. * Customization::        Description of ILISP variables and hooks.
  42. * Dialects::            How ILISP knows how to communicate with Lisp,
  43.                                     and how to define new dialects.
  44.  
  45. Indices:
  46. * Concept index::        General concepts.
  47. * Key index::            ILISP key sequences.
  48. * Command index::        Commands by name.
  49. * Variable index::        Variables and hooks that influence ILISP's
  50.                                    behavior.
  51.  
  52. * Function index::        Internal Emacs Lisp functions.
  53.  
  54. 
  55. File: ilisp.info,  Node: Distribution,  Next: Acknowledgements,  Prev: Top,  Up: Top
  56.  
  57. How to get the latest ILISP distribution.
  58. *****************************************
  59.  
  60.    ILISP is "free"; this means that everyone is free to use it and
  61. free to redistribute it on a free basis.  ILISP is not in the public
  62. domain; it is copyrighted and there are restrictions on its
  63. distribution, but these restrictions are designed to permit
  64. everything
  65. that a good cooperating citizen would want to do.  What is not
  66. allowed is to try to prevent others from further sharing any version
  67. of ILISP that they might get from you.  The precise conditions
  68. appears following this section.
  69.  
  70.    The easiest way to get a copy of ILISP is from someone else who
  71. has it.  You need not ask for permission to do so, or tell any one
  72. else; just copy it.
  73.  
  74.    If you do start using the package, please send mail to
  75. `ccm@cs.cmu.edu' so that I can keep a mailing list of users.  Any
  76. comments or code are also welcome.
  77.  
  78. * Menu:
  79.  
  80. * FTP directions::        FTP directions
  81.  
  82. 
  83. File: ilisp.info,  Node: FTP directions,  Prev: Distribution,  Up: Distribution
  84.  
  85. FTP directions
  86. ==============
  87.  
  88. You can anonymously ftp the source files from CMU:
  89.  
  90.    * Ftp to katmandu.mt.cs.cmu.edu (128.2.250.68)
  91.  
  92.    * login as anonymous, with user@host as password
  93.  
  94.    * `cd pub/ilisp'
  95.  
  96. Get the files you need:
  97.  
  98.    * `get ilisp.tar.Z' or
  99.  
  100.    * `mget README HISTORY *.el *.lisp *.texi *.info *.ps *.dvi *.lcd'
  101.  
  102.    * If Franz gives permission for the Franz online CL manual:  `get
  103.      fi.tar.Z'
  104.  
  105. Unpack and install:
  106.  
  107.   1. `uncompress ilisp.tar.Z; tar xf ilisp.tar'
  108.  
  109.   2. `uncompress fi.tar.Z; tar xf fi.tar'
  110.  
  111.   3.  *Note Installation::.
  112.  
  113. 
  114. File: ilisp.info,  Node: Acknowledgements,  Next: Introduction,  Prev: Distribution,  Up: Top
  115.  
  116. Acknowledgements
  117. ****************
  118.  
  119.    ILISP is based on comint mode and derived from a number of
  120. different interfaces including Symbolics, cmulisp, and Thinking
  121. Machines.  There are many people that have taken the time to report
  122. bugs, make suggestions and even better send code to fix bugs or
  123. implement new features.  Special thanks to Todd Kaufmann for the
  124. texinfo file, work on bridge, epoch-pop and for really exercising
  125. everything.  Thanks to Neil Smithline, David Braunegg, Fred White,
  126. Jim Healy, Larry Stead, Hans Chalupsky, Michael Ernst, Frank Ritter,
  127. Tom Emerson, David Duff, Dan Pierson, Michael Kashket, Jamie
  128. Zawinski, Bjorn Victor and Brian Dennis for bug reports, suggestions
  129. and code.  Please send bug reports, fixes and extensions to
  130. `ccm@cs.cmu.edu' so I can merge them into the master source.
  131.  
  132.      --Chris McConnell  18-Mar-91
  133.  
  134. 
  135. File: ilisp.info,  Node: Introduction,  Next: Installation,  Prev: Acknowledgements,  Up: Top
  136.  
  137. Introduction
  138. ************
  139.  
  140. ILISP is an interface from GNU Emacs to an inferior LISP.  It has the
  141. following features:
  142.  
  143.    * Support for multiple LISP dialects including Lucid, Allegro and
  144.      CMU on multiple machines even at the same time.
  145.  
  146.    * Dynamically sized pop-up windows that can be buried and scrolled
  147.      from any window.
  148.  
  149.    * Packages are properly handled including the distinction between
  150.      exported and internal symbols.
  151.  
  152.    * Synchronous, asynchronous or batch eval and compile of files,
  153.      regions, definitions and sexps with optional switching and
  154.      automatic calling.
  155.  
  156.    * Arglist, documentation, describe, inspect and macroexpand.
  157.  
  158.    * Completion of filename components and LISP symbols including
  159.      partial matches.
  160.  
  161.    * Find source both with and without help from the inferior LISP,
  162.      including CLOS methods, multiple definitions and multiple
  163.      files.  Also works for automatically generated functions like
  164.      defstruct.
  165.  
  166.    * Edit the callers of a function with and without help from the
  167.      inferior LISP.
  168.  
  169.    * Trace/untrace a function.
  170.  
  171.    * `M-q' ("Fill-paragraph") works properly on paragraphs in
  172.      comments, strings and code.
  173.  
  174.    * Find unbalanced parentheses.
  175.  
  176.    * Super brackets.
  177.  
  178.    * Handles editing, entering and indenting full LISP expressions.
  179.  
  180.    * Next, previous, and similar history mechanism compatible with
  181.      comint.
  182.  
  183.    * Handles LISP errors.
  184.  
  185.    * Result histories are maintained in the inferior LISP.
  186.  
  187.    * Does not create spurious symbols and handles case issues.
  188.  
  189.    * Online manuals for ILISP and Common LISP.
  190.  
  191. 
  192. File: ilisp.info,  Node: Installation,  Next: Starting up,  Prev: Introduction,  Up: Top
  193.  
  194. How to install ILISP
  195. ********************
  196.  
  197.    Installation of ILISP and some initialization of your computing
  198. environment are described in this chapter.  Please read the
  199. following sections carefully before getting started with ILISP.
  200.  
  201.    If ILISP has already been installed at your location, you can
  202. probably skip ahead to "Autoloading."
  203.  
  204. * Menu:
  205.  
  206. * Files of ILISP::        
  207. * Autoloading::            How to define autoload entries.
  208.  
  209. 
  210. File: ilisp.info,  Node: Files of ILISP,  Next: Autoloading,  Prev: Installation,  Up: Installation
  211.  
  212. Files of ILISP
  213. ==============
  214.  
  215.    The files you need to use ilisp are:
  216.  
  217. `ilisp.emacs'
  218.      File with sample `.emacs' code for ILISP.
  219.  
  220. `symlink.el'
  221.      Expand pathnames resolving links.
  222.  
  223. `completer.el'
  224.      Partial completion code.
  225.  
  226. `completion.el'
  227.      Completion package from TMC.
  228.  
  229. `popper.el'
  230.      Shrink-wrapped temporary windows.
  231.  
  232. `epoch-pop.el'
  233.      Popper for epoch.
  234.  
  235. `bridge.el'
  236.      Process to process communication.
  237.  
  238. `comint.el'
  239.      The basic comint abstraction.
  240.  
  241. `comint-ipc.el'
  242.      Extensions for sending commands and getting results.
  243.  
  244. `ilisp-ext.el'
  245.      Standalone lisp-mode extensions.
  246.  
  247. `ilisp-src.el'
  248.      ILISP source code module.
  249.  
  250. `ilisp-bat.el'
  251.      ILISP batch code module.
  252.  
  253. `ilisp.el'
  254.      Actual ILISP definitions.
  255.  
  256. `*.lisp'
  257.      ILISP support code.  Each dialect will have one of these files.
  258.  
  259. `*.lcd'
  260.      Package descriptors for the Lisp Code Directory.
  261.  
  262. `fi/*'
  263.      Online Franz Common LISP manual.
  264.  
  265. `ilisp.texi'
  266.      Texinfo file for ILISP.
  267.  
  268.    All of the `.el' files in the ilisp directory and the `fi'
  269. subdirectory should be byte-compiled by typing `C-u M-x
  270. byte-recompile-directory'.  Before compiling, make sure that
  271. load-path has the location of the files on it.  If you plan to use
  272. epoch, you must make sure that the epoch EMACS code is loaded before
  273. compiling `epoch-pop'.  If you do not plan to use epoch, you should
  274. rename the `epoch-pop.el' file to `epoch-pop' so that it will not
  275. get compiled.  The first time a dialect is started, the interface
  276. files will complain about not being compiled, just hit `i' to ignore
  277. the
  278. message.  Once a lisp dialect is started up, you should execute the
  279. command `ilisp-compile-inits' which will compile the `*.lisp' files
  280. and write them to the same directory as the ilisp files.
  281.  
  282.    The binary files should have a unique extension for each different
  283. combination of architecture and LISP dialect.  You will need to
  284. change `ilisp-init-binary-extension' and `ilisp-init-binary-command'
  285. to get additional extensions.  The binary for each different
  286. architecture should be different.  If you want to build the
  287. interface files into a LISP world, you will also need to set
  288. `ilisp-load-inits' to `nil' in the same place that you change
  289. `ilisp-program' to load the LISP world.
  290.  
  291.    There is an `ilisp-site-hook' for initializing site specific stuff
  292. like program locations when ILISP is first loaded.  You may want to
  293. define appropriate autoloads in your system Emacs start up file.
  294.  
  295.    Example site init:
  296.  
  297.      ;;; CMU site
  298.      (setq ilisp-site-hook
  299.            '(lambda ()
  300.              (setq ilisp-motd "CMU ILISP V%s")
  301.              (setq expand-symlinks-rfs-exists t)
  302.              (setq allegro-program "/usr/misc/.allegro/bin/cl")
  303.              (setq lucid-program "/usr/misc/.lucid/bin/lisp")))
  304.  
  305. 
  306. File: ilisp.info,  Node: Autoloading,  Prev: Files of ILISP,  Up: Installation
  307.  
  308. How to define autoload entries
  309. ==============================
  310.  
  311.    These are sample forms for your `.emacs' file.  They can be found
  312. in the file `ilisp.emacs' in the `ilisp-directory'.
  313.  
  314.      ;;;
  315.      ;;; This file shows examples of some of the things you might want to
  316.      ;;; do to install or customize ILISP.  You may not want to include all
  317.      ;;; of them in your .emacs.  For example, the default key binding
  318.      ;;; prefix for ILISP is C-z and this file changes the default prefix to
  319.      ;;; C-c.  For more information on things that can be changed, see the
  320.      ;;; file ilisp.el. 
  321.      ;;;
  322.      
  323.      ;;; If ilisp lives in some non-standard directory, you must tell emacs
  324.      ;;; where to get it. This may or may not be necessary.
  325.      (setq load-path (cons (expand-file-name "~jones/emacs/ilisp/") load-path))
  326.      
  327.      ;;; If you always want partial minibuffer completion
  328.      (require 'completer)
  329.      
  330.      ;;; If want always want TMC completion
  331.      (load "completion")
  332.      (initialize-completions)
  333.      
  334.      ;;; If you want to redefine popper keys
  335.      (setq popper-load-hook
  336.            '(lambda ()
  337.          (define-key global-map "\C-c1" 'popper-bury-output)
  338.          (define-key global-map "\C-cv" 'popper-scroll-output)
  339.          (define-key global-map "\C-cg" 'popper-grow-output)))
  340.      
  341.      ;;; If you always want popper windows
  342.      (require 'popper)
  343.      
  344.      ;;; Autoload based on your LISP.  You only really need the one you use.
  345.      ;;; If called with a prefix, you will be prompted for a buffer and program.
  346.      (autoload 'run-ilisp "ilisp" "Select a new inferior LISP." t)
  347.      (autoload 'clisp     "ilisp" "Inferior generic Common LISP." t)
  348.      (autoload 'allegro   "ilisp" "Inferior Allegro Common LISP." t)
  349.      (autoload 'lucid     "ilisp" "Inferior Lucid Common LISP." t)
  350.      (autoload 'cmulisp   "ilisp" "Inferior CMU Common LISP." t)
  351.      (autoload 'kcl       "ilisp" "Inferior Kyoto Common LISP." t)
  352.      (autoload 'akcl      "ilisp" "Inferior Austin Kyoto Common LISP." t)
  353.      (autoload 'ibcl      "ilisp" "Ibuki Common LISP." t)
  354.      (autoload 'scheme    "ilisp" "Inferior generic Scheme." t)
  355.      (autoload 'oaklisp   "ilisp" "Inferior Oaklisp Scheme." t)
  356.      
  357.      ;;; Define where LISP programs are found.  (This may already be done
  358.      ;;; at your site.)
  359.      (setq allegro-program "/usr/misc/.allegro/bin/cl")
  360.      (setq lucid-program "/usr/misc/.lucid/bin/lisp")
  361.      (setq cmulisp-program "/usr/misc/.cmucl/bin/lisp")
  362.      
  363.      ;;; This makes reading a lisp file load in ilisp.
  364.      (set-default 'auto-mode-alist
  365.               (append '(("\\.lisp$" . lisp-mode)) auto-mode-alist))
  366.      (setq lisp-mode-hook '(lambda () (require 'ilisp)))
  367.      
  368.      ;;; Sample load hook
  369.      (setq ilisp-load-hook 
  370.            '(lambda ()
  371.          ;; Change default key prefix to C-c
  372.          (setq ilisp-prefix "\C-c")
  373.          ;; Sample initialization hook.  Set the inferior LISP directory to
  374.          ;; the directory of the buffer that spawned it on the first prompt.
  375.          (add-hook 'ilisp-init-hook
  376.           (function (lambda ()
  377.             (default-directory-lisp ilisp-last-buffer))))))
  378.      
  379.      ;;; Setup to always show output in the Inferior LISP buffer.
  380.      ;(setq lisp-no-popper t
  381.      ;      comint-always-scroll t)
  382.  
  383. 
  384. File: ilisp.info,  Node: Starting up,  Next: Buffers of ILISP,  Prev: Installation,  Up: Top
  385.  
  386. How to run a Lisp process using ILISP
  387. *************************************
  388.  
  389.    To start a Lisp use `M-x run-ilisp', or a specific dialect like
  390. `M-x allegro'.  If called with a prefix you will be prompted for a
  391. buffer name and a program to run.  The default buffer name is the
  392. name of the dialect.  The default program for a dialect will be the
  393. value of DIALECT-program or the value of ilisp-program inherited
  394. from a less specific dialect.  If there are multiple LISP's, use the
  395. dialect name or `M-x select-ilisp' (`C-z S') to select the current
  396. ILISP buffer.
  397.  
  398.    These are the currently supported dialects.  The dialects are
  399. listed so that the indentation correponds to the hierarchical
  400. relationship between dialects.
  401.  
  402.       clisp
  403.         allegro
  404.         lucid
  405.         kcl
  406.           akcl
  407.           ibcl
  408.         cmulisp
  409.       scheme
  410.         oaklisp
  411.  
  412.    If anyone figures out support for other dialects I would be happy
  413. to include it in future releases.  *Note Dialects::.
  414.  
  415.    Entry into ILISP mode runs the hooks on `comint-mode-hook' and
  416. `ilisp-mode-hook' and then DIALECT-hooks specific to LISP dialects
  417. in the nesting order above.
  418.  
  419. 
  420. File: ilisp.info,  Node: Buffers of ILISP,  Next: ILISP Commands,  Prev: Starting up,  Up: Top
  421.  
  422. Buffers used by ILISP, and their commands
  423. *****************************************
  424.  
  425. `*DIALECT*'
  426.      The Lisp listener buffer.  Forms can be entered in this buffer
  427.      in, and they will be sent to lisp when you hit return if the
  428.      form is complete.  This buffer is in ilisp-mode, which is built
  429.      on top of comint-mode, and all comint commands such as history
  430.      mechanism and job control are available.
  431.  
  432. `LISP-MODE-BUFFERS'
  433.      A buffer is assumed to contain Lisp source code if its major
  434.      mode is in the list `lisp-source-modes'.  If it's loaded into a
  435.      buffer that is in one of these major modes, it's considered a
  436.      lisp source file by `find-file-lisp', `load-file-lisp' and
  437.      `compile-file-lisp'.  Used by these commands to determine
  438.      defaults.
  439.  
  440. ``*Completions*''
  441.      Used for listing completions of symbols or files by the
  442.      completion commands.  *Note Completion::.
  443.  
  444. `*Aborted Commands*'
  445.      *Note Interrupts::.
  446.  
  447. `*Errors*'
  448. `*Output*'
  449. `*Error Output*'
  450.      used to pop-up results and errors from the inferior LISP.
  451.  
  452. `*ilisp-send*'
  453.      Buffer containing the last form sent to the inferior LISP.
  454.  
  455. `*Edit-Definitions*'
  456. `*All-Callers*'
  457.      *Note Source code commands::.
  458.  
  459. `*Last-Changes*'
  460. `*Changed-Definitions*'
  461.      *Note Batch commands::.
  462.  
  463. * Menu:
  464.  
  465. * Popper buffers::        temporary buffers used for display.
  466. * Switching buffers::        Switching buffers
  467.  
  468. 
  469. File: ilisp.info,  Node: Popper buffers,  Next: Switching buffers,  Prev: Buffers of ILISP,  Up: Buffers of ILISP
  470.  
  471. Popper buffers
  472. ==============
  473.  
  474.    ILISP uses a dynamically sized pop-up window that can be buried
  475. and scrolled from any window for displaying output.  By default the
  476. smallest window will have just one line.  If you like bigger
  477. windows, set `window-min-height' to the number of lines desired plus
  478. one.
  479.  
  480.    The variable `popper-pop-buffers' has a list of temporary buffer
  481. names that will be displayed in the pop-up window.  By default only
  482. `*Typeout-window*' and `*Completions*' will be displayed in the
  483. pop-up window (remember to include the leading space in a buffer
  484. name
  485. if it has it).  If you want all temporary windows to use the pop-up
  486. window, set `popper-pop-buffers' to `t'.
  487.  
  488.    The variable `popper-buffers-to-skip' has a list of the buffer
  489. names `C-x o' (`popper-other-window') skips or `t' to skip all
  490. popper buffers.  If `popper-other-window' is called with a `C-u'
  491. prefix,
  492. the popper window will be selected.
  493.  
  494. `C-z 1   (popper-bury-output)'
  495.      buries the output window.
  496.  
  497. `C-z v   (popper-scroll-output)'
  498.      scrolls the output window if it is already showing, otherwise it
  499.      pops it up.  If it is called with a negative prefix, it will
  500.      scroll backwards.
  501.  
  502. `C-z G   (popper-grow-output)'
  503.      will grow the output window if showing by the prefix number of
  504.      lines.  Otherwise, it will pop the window up.
  505.  
  506.    If you are running `epoch', the popper window will be in a
  507. separate X window that is not automatically grown or shrunk.  The
  508. variable `popper-screen-properties' can be used to set window
  509. properties for that window.
  510.  
  511.    An alternative to popper windows is to always have the inferior
  512. LISP buffer visible and have all output go there.  Setting
  513. `lisp-no-popper' to `t' will cause all output to go to the inferior
  514. LISP buffer.  Setting `comint-always-scroll' to `t' will cause
  515. process
  516. output to always be visible.  If a command gets an error, you will
  517. be left in the break loop.
  518.  
  519. 
  520. File: ilisp.info,  Node: Switching buffers,  Prev: Popper buffers,  Up: Buffers of ILISP
  521.  
  522. Switching buffers
  523. =================
  524.  
  525.    Commands to make switching between buffers easier.
  526.  
  527. `C-z b   (switch-to-lisp)'
  528.      will pop to the current ILISP buffer or if already in an ILISP
  529.      buffer, it will return to the buffer that last switched to an
  530.      ILISP buffer.  With a prefix, it will also go to the end of the
  531.      buffer.  If you do not want it to pop, set `pop-up-windows' to
  532.      nil.
  533.  
  534. `M-C-l   (previous-buffer-lisp)'
  535.      will switch to the last visited buffer in the current window or
  536.      the Nth previous buffer with a prefix.
  537.  
  538. 
  539. File: ilisp.info,  Node: ILISP Commands,  Next: Customization,  Prev: Buffers of ILISP,  Up: Top
  540.  
  541. ILISP Commands
  542. **************
  543.  
  544.    Most of these key bindings work in both Lisp Mode and ILISP mode. 
  545. There are a few additional and-go bindings found in Lisp Mode.
  546.  
  547. * Menu:
  548.  
  549. * Eval and compile functions::    
  550. * Documentation functions::    
  551. * Macroexpansion::        
  552. * Tracing functions::        
  553. * Package Commands::        
  554. * Source code commands::    Working on several files
  555. * Batch commands::        Grouping changes for eval/compile
  556. * Files and directories::    
  557. * Keyboard modes::        Interactive and raw keyboard modes
  558. * Interrupts::            Interrupts, aborts, and errors
  559. * Command history::        
  560. * Completion::            
  561. * Miscellany::            Indentation, parenthesis balancing,
  562.                   and comment commands.
  563.  
  564. 
  565. File: ilisp.info,  Node: Eval and compile functions,  Next: Documentation functions,  Prev: ILISP Commands,  Up: ILISP Commands
  566.  
  567. Eval and compile functions
  568. ==========================
  569.  
  570.    In LISP, the major unit of interest is a form, which is anything
  571. between two matching parentheses.  Some of the commands here also
  572. refer to "defun," which is a list that starts at the left margin in
  573. a LISP buffer, or after a prompt in the ILISP buffer.  These
  574. commands refer to the "defun" that contains the point.
  575.  
  576.    "A call" refers to a reference to a function call for a function
  577. or macro, or a reference to a variable.  Commands which "insert a
  578. call" in the ILISP buffer will bring up the last command which
  579. matches it or else will insert a template for a call.
  580.  
  581.    When an eval is done of a single form matching
  582. `ilisp-defvar-regexp' the corresponding symbol will be unbound and
  583. the value assigned again.
  584.  
  585.    When you send a form to LISP, the status light will reflect the
  586. progress of the command.  In a lisp mode buffer the light will
  587. reflect the status of the currently selected inferior LISP unless
  588. `lisp-show-status' is nil.  If you want to find out what command is
  589. currently running, use the command `C-z s' (status-lisp).  If you
  590. call it with a prefix, the pending commands will be displayed as well.
  591.  
  592.    Note that in this table as elsewhere, the key C-z (ilisp-prefix)
  593. is used as a prefix character for ILISP commands, though this may be
  594. changed.  For a full list of key-bindings, use `M-x describe-mode'
  595. or `M-x describe-bindings' while in an ILISP-mode buffer.
  596.  
  597.    The eval/compile commands verify that their expressions are
  598. balanced and then send the form to the inferior LISP.  If called
  599. with a positive prefix, the result of the operation will be inserted
  600. into the buffer after the form that was just sent.
  601.  
  602.    For commands which operate on a region, the result of the compile
  603. or eval is the last form in the region.
  604.  
  605.    The `and-go' versions will perform the operation and then
  606. immediately switch to the ILISP buffer where you will see the
  607. results of executing your form.  If `eval-defun-and-go-lisp' or
  608. `compile-defun-and-go-lisp' is called with a prefix, a call for the
  609. form will be inserted as well.
  610.  
  611. `C-z'
  612.      The prefix-key for most ILISP commands.  This can be changed by
  613.      setting the variable `ilisp-prefix'.
  614.  
  615. `RET   (return-ilisp)'
  616.      In ILISP-mode buffer, sends the current form to lisp if
  617.      complete, otherwise creates a new line and indents.  If you
  618.      edit old input, the input will be copied to the end of the
  619.      buffer first and then sent.
  620.  
  621. `C-]   (close-and-send-lisp)'
  622.      Closes the current sexp, indents it, and then sends it to the
  623.      current inferior LISP.
  624.  
  625. `LFD   (newline-and-indent-lisp)'
  626.      Insert a new line and then indent to the appropriate level.  If
  627.      called at the end of the inferior LISP buffer and an sexp, the
  628.      sexp will be sent to the inferior LISP without a trailing
  629.      newline.
  630.  
  631. `C-z e   (eval-defun-lisp)'
  632. `M-C-x   (eval-defun-lisp)'
  633. `C-z C-e   (eval-defun-and-go-lisp)'
  634.      Send the defun to lisp.
  635.  
  636. `C-z r   (eval-region-lisp)'
  637. `C-z C-r   (eval-region-and-go-lisp)'
  638. `C-z n   (eval-next-sexp-lisp)'
  639. `C-z C-n   (eval-next-sexp-and-go-lisp)'
  640. `C-z c   (compile-defun-lisp)'
  641. `C-z C-c   (compile-defun-lisp-and-go)'
  642.      When `compile-defun-lisp' is called in an inferior LISP buffer
  643.      with no current form, the last form typed to the top-level will
  644.      be compiled.
  645.  
  646. `C-z w   (compile-region-lisp)'
  647. `C-z C-w   (compile-region-and-go-lisp)'
  648.    If any of the forms contain an interactive command, then the
  649. command will never return.  To get out of this state, you need to
  650. use `abort-commands-lisp' (`C-z g').  If `lisp-wait-p' is t, then
  651. EMACS will display the result of the command in the minibuffer or a
  652. pop-up window.  If `lisp-wait-p' is `nil', (the default) the send is
  653. done asynchronously and the results will be brought up only if there
  654. is more than one line or there is an error.  In this case, you will
  655. be given the option of ignoring the error, keeping it in another
  656. buffer or keeping it and aborting all pending sends.  If there is
  657. not a command already running in the inferior LISP, you can preserve
  658. the break loop.  If called with a negative prefix, the sense of
  659. `lisp-wait-p' will be inverted for the next command.
  660.  
  661. 
  662. File: ilisp.info,  Node: Documentation functions,  Next: Macroexpansion,  Prev: Eval and compile functions,  Up: ILISP Commands
  663.  
  664. Documentation functions
  665. =======================
  666.  
  667.    `describe-lisp', `inspect-lisp', `arglist-lisp', and
  668. `documentation-lisp' switch whether they prompt for a response or
  669. use a default when called with a negative prefix.  If they are
  670. prompting, there is completion through the inferior LISP by using
  671. `TAB' or `M-TAB'.  When entering an expression in the minibuffer,
  672. all of the normal ilisp commands like `arglist-lisp' also work.
  673.  
  674.    Commands that work on a function will use the nearest previous
  675. function symbol.  This is either a symbol after a `#'' or the symbol
  676. at the start of the current list.
  677.  
  678. `C-z a   (arglist-lisp)'
  679.      Return the arglist of the current function.  With a numeric
  680.      prefix, the leading paren will be removed and the arglist will
  681.      be inserted into the buffer.
  682.  
  683. `C-z d   (documentation-lisp)'
  684.      Infers whether function or variable documentation is desired. 
  685.      With a negative prefix, you can specify the type of
  686.      documentation as well.  With a positive prefix the
  687.      documentation of the current function call is inserted into the
  688.      buffer.
  689.  
  690. `C-z i   (describe-lisp)'
  691.      Describe the previous sexp (it is evaluated).  If there is no
  692.      previous sexp and if called from inside an ILISP buffer, the
  693.      previous result will be described.
  694.  
  695. `C-z i   (describe-lisp)'
  696.      Describe the previous sexp (it is evaluated).  If there is no
  697.      previous sexp and if called from inside an ILISP buffer, the
  698.      previous result will be described.
  699.  
  700. `C-z I   (inspect-lisp)'
  701.      Switch to the current inferor LISP and inspect the previous sexp
  702.      (it is evaluated).  If there is no previous sexp and if called
  703.      from inside an ILISP buffer, the previous result will be
  704.      inspected.
  705.  
  706. `C-z D   (fi:clman)'
  707. `C-z A   (fi:clman-apropos)'
  708.      If the Franz online Common LISP manual is available, get
  709.      information on a specific symbol.  `fi:clman-apropos' will get
  710.     
  711.      information apropos a specific string.  Some of the
  712.      documentation is specific to the allegro dialect, but most of
  713.      it is for standard Common LISP.
  714.  
  715. 
  716. File: ilisp.info,  Node: Macroexpansion,  Next: Tracing functions,  Prev: Documentation functions,  Up: ILISP Commands
  717.  
  718. Macroexpansion
  719. ==============
  720.  
  721. `C-z M   (macroexpand-lisp)'
  722. `C-z m   (macroexpand-1-lisp)'
  723.      These commands apply to the next sexp.  If called with a
  724.      positive numeric prefix, the result of the macroexpansion will
  725.      be inserted into the buffer.  With a negative prefix, prompts
  726.      for expression to expand.
  727.  
  728. 
  729. File: ilisp.info,  Node: Tracing functions,  Next: Package Commands,  Prev: Macroexpansion,  Up: ILISP Commands
  730.  
  731. Tracing functions
  732. =================
  733.  
  734. `C-z t   (trace-defun-lisp)'
  735.      traces the current defun.   When called with a numeric prefix
  736.      the function will be untraced.  When called with negative
  737.      prefix, prompts for function to be traced.
  738.  
  739. 
  740. File: ilisp.info,  Node: Package Commands,  Next: Source code commands,  Prev: Tracing functions,  Up: ILISP Commands
  741.  
  742. Package Commands
  743. ================
  744.  
  745.    The first time an inferior LISP mode command is executed in a Lisp
  746. Mode buffer, the package will be determined by using the regular
  747. expression `ilisp-package-regexp' to find a package sexp and then
  748. passing that sexp to the inferior LISP through
  749. `ilisp-package-command'.  For the `clisp' dialect, this will find
  750. the first `(in-package PACKAGE)' form in the file.  A buffer's
  751. package will be displayed in the mode line.  If a buffer has no
  752. specification, forms will be evaluated in the current inferior LISP
  753. package.
  754.  
  755. `C-z p   (package-lisp)'
  756.      Show the current package of the inferior LISP.
  757.  
  758. `C-z P   (set-package-lisp)'
  759.      Set the inferior LISP package to the current buffer's package or
  760.      with a prefix to a manually entered package.
  761.  
  762. `M-x set-buffer-package-lisp'
  763.      Set the buffer's package from the buffer.  If it is called with
  764.      a prefix, the package can be set manually.
  765.  
  766. 
  767. File: ilisp.info,  Node: Source code commands,  Next: Batch commands,  Prev: Package Commands,  Up: ILISP Commands
  768.  
  769. Source Code Commands
  770. ====================
  771.  
  772.    The following commands all deal with finding things in source code.
  773. The first time that one of these commands is used, there may be some
  774. delay while the source module is loaded.  When searching files, the
  775. first applicable rule is used:
  776.  
  777.    * try the inferior LISP,
  778.  
  779.    * try a tags file if defined,
  780.  
  781.    * try all buffers in one of `lisp-source-modes' or all files
  782.      defined using `lisp-directory'.
  783.  
  784.    `M-x lisp-directory' defines a set of files to be searched by the
  785. source code commands.  It prompts for a directory and sets the
  786. source
  787. files to be those in the directory that match entries in
  788. `auto-mode-alist' for modes in `lisp-source-modes'.  With a positive
  789. prefix, the files are appended.  With a negative prefix, all current
  790. buffers that are in one of `lisp-source-modes' will be searched. 
  791. This is also what happens by default.  Using this command stops
  792. using a tags file.
  793.  
  794.    `edit-definitions-lisp', `who-calls-lisp', and `edit-callers-lisp'
  795. will switch whether they prompt for a response or use a default when
  796. called with a negative prefix.  If they are prompting, there is
  797. completion through the inferior LISP by using `TAB' or `M-TAB'. 
  798. When entering an expression in the minibuffer, all of the normal
  799. ILISP commands like `arglist-lisp' also work.
  800.  
  801.    `edit-definitions-lisp' (`M-.') will find a particular type of
  802. definition for a symbol.  It tries to use the rules described above.
  803. The files to be searched are listed in the buffer
  804. `*Edit-Definitions*'.  If `lisp-edit-files' is nil, no search will
  805. be done if not found through the inferior LISP.  The variable
  806. `ilisp-locator' contains a function that when given the name and
  807. type should be able to find the appropriate definition in the file. 
  808. There is often a flag to cause your LISP to record source files that
  809. you
  810. will need to set in the initialization file for your LISP.  The
  811. variable is `*record-source-files*' in both allegro and lucid.  Once
  812. a definition has been found, `next-definition-lisp' (`M-,') will
  813. find the next definition (or the previous definition with a prefix).
  814.  
  815.    `edit-callers-lisp' (`C-z ^') will generate a list of all of the
  816. callers of a function in the current inferior LISP and edit the
  817. first caller using `edit-definitions-lisp'.  Each successive call to
  818. `next-caller-lisp' (`M-`') will edit the next caller (or the
  819. previous caller with a prefix).  The list is stored in the buffer
  820. `*All-Callers*'.  You can also look at the callers by doing `M-x
  821. who-calls-lisp'.
  822.  
  823.    `search-lisp' (`M-?') will search the current tags files,
  824. `lisp-directory' files or buffers in one of `lisp-source-modes' for
  825. a
  826. string or a regular expression when called with a prefix. 
  827. `next-definition-lisp' (`M-,') will find the next definition (or the
  828. previous definition with a prefix).
  829.  
  830.    `replace-lisp' (`M-"') will replace a string (or a regexp with a
  831. prefix) in the current tags files, `lisp-directory' files or buffers
  832. in one of `lisp-source-modes'.
  833.  
  834.    Here is a summary of the above commands (behavior when given
  835. prefix argument is given in parentheses):
  836.  
  837. `M-x lisp-directory'
  838.      Define a set of files to be used by the source code commands.
  839.  
  840. `M-.   (edit-definitions-lisp)'
  841.      Find definition of a symbol.
  842.  
  843. `M-,   (next-definition-lisp)'
  844.      Find next (previous) definition.
  845.  
  846. `C-z ^   (edit-callers-lisp)'
  847.      Find all callers of a function, and edit the first.
  848.  
  849. `M-`   (next-caller-lisp)'
  850.      Edit next (previous) caller of function set by
  851.      `edit-callers-lisp'.
  852.  
  853. `M-x who-calls-lisp'
  854.      List all the callers of a function.
  855.  
  856. `M-?   (search-lisp)'
  857.      Search for string (regular expression) in current tags,
  858.      `lisp-directory' files or buffers.  Use `next-definition-lisp'
  859.     
  860.      to find next occurence.
  861.  
  862. `M-"   (replace-lisp)'
  863.      Replace a string (regular expression) in files.
  864.  
  865. 
  866. File: ilisp.info,  Node: Batch commands,  Next: Files and directories,  Prev: Source code commands,  Up: ILISP Commands
  867.  
  868. Batch commands
  869. ==============
  870.  
  871.    The following commands all deal with making a number of changes
  872. all at once.  The first time one of these commands is used, there
  873. may be some delay as the module is loaded.  The eval/compile
  874. versions of these commands are always executed asynchronously.
  875.  
  876.    `mark-change-lisp' (`C-z SPC') marks the current defun as being
  877. changed.  A prefix causes it to be unmarked.  `clear-changes-lisp'
  878. (`C-z * 0') will clear all of the changes.  `list-changes-lisp'
  879. (`C-z * l') will show the forms currently marked.
  880.  
  881.    `eval-changes-lisp' (`C-z * e'), or `compile-changes-lisp' (`C-z *
  882. c') will evaluate or compile these changes as appropriate.  If
  883. called with a positive prefix, the changes will be kept.  If there
  884. is an error, the process will stop and show the error and all
  885. remaining changes will remain in the list.  All of the results will
  886. be kept in the buffer `*Last-Changes*'.
  887.  
  888. Summary:
  889.  
  890. `C-z SPC   (mark-change-lisp)'
  891.      Mark (unmark) current defun as changed.
  892.  
  893. `C-z * e   (eval-changes-lisp)'
  894. `C-z * c   (compile-changes-lisp)'
  895.      Call with a positive prefix to keep changes.
  896.  
  897. `C-z * 0   (clear-changes-lisp)'
  898. `C-z * l   (list-changes-lisp)'
  899. 
  900. File: ilisp.info,  Node: Files and directories,  Next: Keyboard modes,  Prev: Batch commands,  Up: ILISP Commands
  901.  
  902. Files and directories
  903. =====================
  904.  
  905.    File commands in lisp-source-mode buffers keep track of the last
  906. used directory and file.  If the point is on a string, that will be
  907. the default if the file exists.  If the buffer is one of
  908. `lisp-source-modes', the buffer file will be the default. 
  909. Otherwise, the last file used in a lisp-source-mode will be used.
  910.  
  911. `C-x C-f   (find-file-lisp)'
  912.      will find a file.  If it is in a string, that will be used as
  913.      the default if it matches an existing file.  Symbolic links are
  914.      expanded so that different references to the same file will end
  915.      up with the same buffer.
  916.  
  917. `C-z l   (load-file-lisp)'
  918.      will load a file into the inferior LISP.  You will be given the
  919.      opportunity to save the buffer if it has changed and to compile
  920.      the file if the compiled version is older than the current
  921.      version.
  922.  
  923. `C-z k   (compile-file-lisp)'
  924.      will compile a file in the current inferior LISP.
  925.  
  926. `C-z !   (default-directory-lisp)'
  927.      sets the default inferior LISP directory to the directory of the
  928.      current buffer.  If called in an inferior LISP buffer, it sets
  929.      the Emacs `default-directory' to the LISP default directory.
  930.  
  931. 
  932. File: ilisp.info,  Node: Keyboard modes,  Next: Interrupts,  Prev: Files and directories,  Up: ILISP Commands
  933.  
  934. Switching between interactive and raw keyboard modes
  935. ====================================================
  936.  
  937.    There are two keyboard modes for interacting with the inferior
  938. LISP, \"interactive\" and \"raw\".  Normally you are in interactive
  939. mode where keys are interpreted as commands to EMACS and nothing is
  940. sent
  941. to the inferior LISP unless a specific command does so.  In raw
  942. mode, all characters are passed directly to the inferior LISP
  943. without any interpretation as EMACS commands.  Keys will not be
  944. echoed unless ilisp-raw-echo is T.
  945.  
  946.    Raw mode can be turned on interactively by the command
  947. `raw-keys-ilisp' (`C-z #') and will continue until you type C-g. 
  948. Raw mode can also be turned on/off by inferior LISP functions if the
  949. command `io-bridge-ilisp' (M-x io-bridge-ilisp) has been executed in
  950. the inferior LISP either interactively or on a hook.  To turn on raw
  951. mode,
  952. a function should print ^[1^] and to turn it off should print ^[0^].
  953. An example in Common LISP would be:
  954.  
  955.    `(progn (format t "") (print (read-char)) (format t ""))'
  956.  
  957. 
  958. File: ilisp.info,  Node: Interrupts,  Next: Command history,  Prev: Keyboard modes,  Up: ILISP Commands
  959.  
  960. Interrupts, aborts, and errors
  961. ==============================
  962.  
  963.    If you want to abort the last command you can use `C-g'.
  964.  
  965.    If you want to abort all commands, you should use the command
  966. `abort-commands-lisp' (`C-z g').  Commands that are aborted will be
  967. put in the buffer `*Aborted Commands*' so that you can see what was
  968. aborted.  If you want to abort the currently running top-level
  969. command, use `interrupt-subjob-ilisp' (`C-c C-c').  As a last
  970. resort, `M-x panic-lisp' will reset the ILISP state without
  971. affecting the inferior LISP so that you can see what is happening.
  972.  
  973.    `delete-char-or-pop-ilisp' (`C-d') will delete prefix characters
  974. unless you are at the end of an ILISP buffer in which case it will
  975. pop one level in the break loop.
  976.  
  977.    `reset-ilisp', (`C-z z') will reset the current inferior LISP's
  978. top-level so that it will no longer be in a break loop.
  979.  
  980.    Summary:
  981.  
  982. `C-c C-c   (interrupt-subjob-ilisp)'
  983.      Send a keyboard interrupt signal to lisp.
  984.  
  985. `C-z g    (abort-commands-lisp)'
  986.      Abort all running or unsent commands.
  987.  
  988. `M-x panic-lisp (panic-lisp)'
  989.      Reset the ILISP process state.
  990.  
  991. `C-z z   (reset-ilisp)'
  992.      Reset lisp to top-level.
  993.  
  994. `C-d   (delete-char-or-pop-ilisp)'
  995.      If at end of buffer, pop a level in break loop.
  996.  
  997.    If `lisp-wait-p' is `nil'  (the default), all sends are done
  998. asynchronously and the results will be brought up only if there is
  999. more
  1000. than one line or there is an error.  In case, you will be given the
  1001. option of ignoring the error, keeping it in another buffer or
  1002. keeping it and aborting all pending sends.  If there is not a
  1003. command already running in the inferior LISP, you can preserve the
  1004. break loop.  If called with a negative prefix, the sense of
  1005. `lisp-wait-p' will be inverted for the next command.
  1006.  
  1007. 
  1008. File: ilisp.info,  Node: Command history,  Next: Completion,  Prev: Interrupts,  Up: ILISP Commands
  1009.  
  1010. Command history
  1011. ===============
  1012.  
  1013.    ILISP mode is built on top of `comint-mode', the general
  1014. command-interpreter-in-a-buffer mode.  As such, it inherits many
  1015. commands
  1016. and
  1017. features from this, including a command history mechanism.
  1018.  
  1019.    Each ILISP buffer has a command history associated with it. 
  1020. Commands that do not match `ilisp-filter-regexp' and that are longer
  1021. than `ilisp-filter-length' and that do not match the immediately
  1022. prior command will be added to this history.
  1023.  
  1024. `M-n   (comint-next-input)'
  1025. `M-p   (comint-previous-input)'
  1026.      Cycle through the input history.
  1027.  
  1028. `M-s    (comint-previous-similar-input)'
  1029.      Cycle through input that has the string typed so far as a prefix.
  1030.  
  1031. `M-N    (comint-psearch-input)'
  1032.      Search forwards for prompt.
  1033.  
  1034. `M-P    (comint-msearch-input)'
  1035.      Search backwards for prompt.
  1036.  
  1037. `C-c R   (comint-msearch-input-matching)'
  1038.      Search backwards for occurrence of prompt followed by string
  1039.      which is prompted for (*not* a regular expression).
  1040.  
  1041.    See `comint-mode' documentation for more information on `comint'
  1042. commands.
  1043.  
  1044. 
  1045. File: ilisp.info,  Node: Completion,  Next: Miscellany,  Prev: Command history,  Up: ILISP Commands
  1046.  
  1047. Completion
  1048. ==========
  1049.  
  1050.    Commands to reduce number of keystrokes.
  1051.  
  1052. `M-TAB   (complete-lisp)'
  1053.      will try to complete the previous symbol in the current inferior
  1054.      LISP.  Partial completion is supported unless
  1055.      `ilisp-prefix-match' is set to `t'.  (If you set it to `t',
  1056.      inferior LISP completions will be faster.) With partial
  1057.      completion, `p--n' would complete to `position-if-not' in
  1058.      Common LISP.  If the symbol follows a left paren or a `#'',
  1059.      only symbols with function cells will be considered.  If the
  1060.      symbol starts with a `*' or you call with a positive prefix all
  1061.     
  1062.      possible completions will be considered.  Only external symbols
  1063.      are considered if there is a package qualification with only
  1064.      one colon.  The first time you try to complete a string the
  1065.      longest common substring will be inserted and the cursor will
  1066.      be left on the point of ambiguity.  If you try to complete
  1067.      again, you can see the possible completions.  If you are in a
  1068.      string, then filename completion will be done instead.  And if
  1069.      you try to complete a filename twice, you will see a list of
  1070.      possible completions.  Filename components are completed
  1071.      individually, so `/u/mi/' could expand to `/usr/misc/'.  If you
  1072.     
  1073.     
  1074.      complete with a negative prefix, the most recent completion
  1075.      (symbol or filename) will be undone.
  1076.  
  1077. `M-RET   (complete)'
  1078.      will complete the current symbol to the most recently seen
  1079.      symbol in Emacs that matches what you have typed so far. 
  1080.      Executing it repeatedly will cycle through potential matches. 
  1081.      This is from the TMC completion package and there may be some
  1082.      delay as it is initially loaded.
  1083.  
  1084. 
  1085. File: ilisp.info,  Node: Miscellany,  Prev: Completion,  Up: ILISP Commands
  1086.  
  1087. Miscellany
  1088. ==========
  1089.  
  1090.    Indentation, parenthesis balancing, and comment commands.
  1091.  
  1092. ``TAB'   (indent-line-ilisp)'
  1093.      indents for LISP.  With prefix, shifts rest of expression
  1094.      rigidly with the current line.
  1095.  
  1096. `M-C-q   (indent-sexp-ilisp)'
  1097.      will indent each line in the next sexp.
  1098.  
  1099. `M-q   (reindent-lisp)'
  1100.      will reindent the current paragraph if in a comment or string. 
  1101.      Otherwise it will close the containing defun and reindent it.
  1102.  
  1103. `C-z ;   (comment-region-lisp)'
  1104.      will put prefix copies of `comment-start' before and
  1105.      `comment-end''s after the lines in region.  To uncomment a
  1106.      region, use a minus prefix.
  1107.  
  1108. `C-z )   (find-unbalanced-lisp)'
  1109.      will find unbalanced parens in the current buffer.  When called
  1110.      with a prefix it will look in the current region.
  1111.  
  1112. `]   (close-all-lisp)'
  1113.      will close all outstanding parens back to the containing form,
  1114.      or a previous left bracket which will be converted to a left
  1115.      parens.  If there are too many parens, they will be deleted
  1116.      unless there is text between the last paren and the end of the
  1117.      defun.  If called with a prefix, all open left brackets will be
  1118.      closed.
  1119.  
  1120. 
  1121. File: ilisp.info,  Node: Customization,  Next: Dialects,  Prev: ILISP Commands,  Up: Top
  1122.  
  1123. ILISP Customization
  1124. *******************
  1125.  
  1126.    Starting a dialect runs the hooks on `comint-mode-hook' and
  1127. `ilisp-mode-hook' and then DIALECT`-hooks' specific to dialects in
  1128. the
  1129. nesting order below.
  1130.  
  1131.       clisp
  1132.         allegro
  1133.         lucid
  1134.         kcl
  1135.           akcl
  1136.           ibcl
  1137.         cmulisp
  1138.       scheme
  1139.         oaklisp
  1140.  
  1141.    On the very first prompt in the inferior LISP, the hooks on
  1142. `ilisp-init-hook' are run.  For more information on creating a new
  1143. dialect
  1144. or variables to set in hooks, see `ilisp.el'.
  1145.  
  1146.    ILISP Mode Hooks:
  1147.  
  1148. `ilisp-site-hook'
  1149.      Executed when file is loaded
  1150.  
  1151. `ilisp-load-hook'
  1152.      Executed when file is loaded
  1153.  
  1154. `ilisp-mode-hook'
  1155.      Executed when an ilisp buffer is created
  1156.  
  1157. `ilisp-init-hook'
  1158.      Executed after inferior LISP is initialized and the first prompt
  1159.      is seen.
  1160.  
  1161. `DIALECT-hook'
  1162.      Executed when dialect is set
  1163.  
  1164.    Variables you might want to set in a hook or dialect:
  1165.  
  1166. `ilisp-prefix'
  1167.      Keys to prefix ilisp key bindings
  1168.  
  1169. `ilisp-program'
  1170.      Program to start for inferior LISP
  1171.  
  1172. `ilisp-motd'
  1173.      String printed on startup with version
  1174.  
  1175. `lisp-wait-p'
  1176.      Set to T for synchronous sends
  1177.  
  1178. `lisp-no-popper'
  1179.      Set to T to have all output in inferior LISP
  1180.  
  1181. `lisp-show-status'
  1182.      Set to nil to stop showing process status
  1183.  
  1184. `ilisp-prefix-match'
  1185.      Set to T if you do not want partial completion
  1186.  
  1187. `ilisp-filter-regexp'
  1188.      Input history filter
  1189.  
  1190. `ilisp-filter-length'
  1191.      Input history minimum length
  1192.  
  1193. `ilisp-other-prompt'
  1194.      Prompt for non- top-level read-eval print loops
  1195.  
  1196. 
  1197. File: ilisp.info,  Node: Dialects,  Next: Concept index,  Prev: Customization,  Up: Top
  1198.  
  1199. Dialects
  1200. ********
  1201.  
  1202.    A "dialect" of lisp is a specific implementation.  For the parts
  1203. of Common Lisp which are well specified, they are usually the same. 
  1204. For the parts that are not (debugger, top-level loop, etc.), there
  1205. is usually the same functionality but different commands.
  1206.  
  1207.    ILISP provides the means to specify these differences so that the
  1208. ILISP commands will use the specific command peculiar to an
  1209. implementation, but still offer the same behavior with the same
  1210. interface.
  1211.  
  1212. * Menu:
  1213.  
  1214. * Defining new dialects::    
  1215. * Writing new commands::    
  1216.  
  1217. 
  1218. File: ilisp.info,  Node: Defining new dialects,  Next: Writing new commands,  Prev: Dialects,  Up: Dialects
  1219.  
  1220. Defining new dialects
  1221. =====================
  1222.  
  1223.    To define a new dialect use the macro `defdialect'.  For examples,
  1224. look at the dialect definitions in `ilisp.el'.  There are hooks and
  1225. variables for almost anything that you are likely to need to change.
  1226. The relationship between dialects is hierarchical with the root
  1227. values being defined in `setup-ilisp'.  For a new dialect, you only
  1228. need to change the variables that are different than in the parent
  1229. dialect.
  1230.  
  1231. 
  1232. File: ilisp.info,  Node: Writing new commands,  Prev: Defining new dialects,  Up: Dialects
  1233.  
  1234. Writing new commands
  1235. ====================
  1236.  
  1237.    Basic tools for creating new commands:
  1238.  
  1239. `deflocal'
  1240.      Define a new buffer local variable.
  1241.  
  1242. `ilisp-dialect'
  1243.      List of dialect types.  For specific dialect clauses.
  1244.  
  1245. `lisp-symbol'
  1246.      Create a symbol.
  1247.  
  1248. `lisp-symbol-name'
  1249.      Return a symbol's name
  1250.  
  1251. `lisp-symbol-delimiter'
  1252.      Return a symbol's qualification
  1253.  
  1254. `lisp-symbol-package'
  1255.      Return a symbol's package
  1256.  
  1257. `lisp-string-to-symbol'
  1258.      Convert string to symbol
  1259.  
  1260. `lisp-symbol-to-string'
  1261.      Convert symbol to string
  1262.  
  1263. `lisp-buffer-symbol'
  1264.      Convert symbol to string qualified for buffer
  1265.  
  1266. `lisp-previous-symbol'
  1267.      Return previous symbol
  1268.  
  1269. `lisp-previous-sexp'
  1270.      Return previous sexp
  1271.  
  1272. `lisp-def-name'
  1273.      Return name of current definition
  1274.  
  1275. `lisp-function-name'
  1276.      Return previous function symbol
  1277.  
  1278. `ilisp-read'
  1279.      Read an sexp with completion, arglist, etc
  1280.  
  1281. `ilisp-read-symbol'
  1282.      Read a symbol or list with completion
  1283.  
  1284. `ilisp-completing-read'
  1285.      Read from choices or list with completion
  1286.  
  1287. Notes:
  1288.  
  1289.    * Special commands like arglist should use `ilisp-send' to send a
  1290.      message to the inferior LISP.
  1291.  
  1292.    * Eval/compile commands should use `eval-region-lisp' or
  1293.      `compile-region-lisp'.
  1294.  
  1295. 
  1296. File: ilisp.info,  Node: Concept index,  Next: Key index,  Prev: Dialects,  Up: Top
  1297.  
  1298. Concept Index
  1299. *************
  1300.  
  1301. * Menu:
  1302.  
  1303. * *Aborted Commands* buffer:            Buffers of ILISP.
  1304. * *Aborted Commands* buffer:            Interrupts.
  1305. * *All-Callers* buffer:                 Source code commands.
  1306. * *All-Callers* buffer:                 Buffers of ILISP.
  1307. * *Changed-Definitions* buffer:         Buffers of ILISP.
  1308. * *Completions* buffer:                 Buffers of ILISP.
  1309. * *Edit-Definitions* buffer:            Source code commands.
  1310. * *Edit-Definitions* buffer:            Buffers of ILISP.
  1311. * *Error Output* buffer:                Buffers of ILISP.
  1312. * *Errors* buffer:                      Buffers of ILISP.
  1313. * *Last-Changes* buffer:                Buffers of ILISP.
  1314. * *Last-Changes* buffer:                Batch commands.
  1315. * *Output* buffer:                      Buffers of ILISP.
  1316. * *ilisp-send* buffer:                  Buffers of ILISP.
  1317. * comint-mode:                          Command history.
  1318. * .el files:                            Files of ILISP.
  1319. * .emacs forms:                         Autoloading.
  1320. * bridge.el:                            Files of ILISP.
  1321. * comint-ipc.el:                        Files of ILISP.
  1322. * comint.el:                            Files of ILISP.
  1323. * completer.el:                         Files of ILISP.
  1324. * completion.el:                        Files of ILISP.
  1325. * epoch-pop.el:                         Files of ILISP.
  1326. * ilisp-bat.el:                         Files of ILISP.
  1327. * ilisp-ext.el:                         Files of ILISP.
  1328. * ilisp-src.el:                         Files of ILISP.
  1329. * ilisp.el:                             Files of ILISP.
  1330. * ilisp.emacs:                          Files of ILISP.
  1331. * ilisp.texi:                           Files of ILISP.
  1332. * popper.el:                            Files of ILISP.
  1333. * symlink.el:                           Files of ILISP.
  1334. * and-go functions:                     Eval and compile functions.
  1335. * Aborting commands:                    Interrupts.
  1336. * Anonymous FTP:                        FTP directions.
  1337. * Apropos help:                         Documentation functions.
  1338. * Arglist lisp:                         Documentation functions.
  1339. * Break loop:                           Interrupts.
  1340. * Buffer package:                       Package Commands.
  1341. * Byte-compiling ILISP files:           Files of ILISP.
  1342. * Call:                                 Eval and compile functions.
  1343. * Change commands:                      Batch commands.
  1344. * Clearing changes:                     Batch commands.
  1345. * Close all parens:                     Miscellany.
  1346. * Close brackets:                       Miscellany.
  1347. * Command history:                      Command history.
  1348. * Comment region:                       Miscellany.
  1349. * Common Lisp manual:                   Documentation functions.
  1350. * Compile last form:                    Eval and compile functions.
  1351. * Compile region:                       Eval and compile functions.
  1352. * Compile/eval commands:                Eval and compile functions.
  1353. * Compiling ILISP files:                Files of ILISP.
  1354. * Compiling changes:                    Batch commands.
  1355. * Compiling files:                      Files and directories.
  1356. * Completion:                           Completion.
  1357. * Current directory:                    Files and directories.
  1358. * Currently running command:            Eval and compile functions.
  1359. * Customization:                        Customization.
  1360. * Default directory:                    Files and directories.
  1361. * Defining new dialects:                Defining new dialects.
  1362. * Defun:                                Eval and compile functions.
  1363. * Describing bindings:                  Eval and compile functions.
  1364. * Describing lisp objects:              Documentation functions.
  1365. * Dialect startup:                      Customization.
  1366. * Dialects:                             Dialects.
  1367. * Dialects supported:                   Starting up.
  1368. * Directories and files:                Files and directories.
  1369. * Displaying commands:                  Eval and compile functions.
  1370. * Documentation Functions:              Documentation functions.
  1371. * Errors:                               Interrupts.
  1372. * Eval region:                          Eval and compile functions.
  1373. * Eval'ing changes:                     Batch commands.
  1374. * Eval/compile commands:                Eval and compile functions.
  1375. * Expanding macro forms:                Macroexpansion.
  1376. * FTP site:                             FTP directions.
  1377. * File changes:                         Batch commands.
  1378. * Filename completion:                  Completion.
  1379. * Files and directories:                Files and directories.
  1380. * Files of ILISP:                       Files of ILISP.
  1381. * Find callers:                         Source code commands.
  1382. * Find file:                            Files and directories.
  1383. * Find unbalanced parens:               Miscellany.
  1384. * Finding source:                       Source code commands.
  1385. * First prompt:                         Customization.
  1386. * Franz manual:                         Documentation functions.
  1387. * Getting ILISP:                        FTP directions.
  1388. * Group changes:                        Batch commands.
  1389. * Hooks:                                Customization.
  1390. * How to get:                           FTP directions.
  1391. * ILISP Mode Hooks:                     Customization.
  1392. * ILISP buffers:                        Buffers of ILISP.
  1393. * In-package form:                      Package Commands.
  1394. * Indentation:                          Miscellany.
  1395. * Input search:                         Command history.
  1396. * Inserting calls:                      Eval and compile functions.
  1397. * Inserting results:                    Eval and compile functions.
  1398. * Installation:                         Installation.
  1399. * Interactive keyboard mode:            Keyboard modes.
  1400. * Internal ILISP functions:             Writing new commands.
  1401. * Interrupting commands:                Interrupts.
  1402. * Last command:                         Command history.
  1403. * Lisp find file:                       Files and directories.
  1404. * List callers:                         Source code commands.
  1405. * Listing bindings:                     Eval and compile functions.
  1406. * Listing changes:                      Batch commands.
  1407. * Loading files:                        Files and directories.
  1408. * Macroexpansion:                       Macroexpansion.
  1409. * Marking changes:                      Batch commands.
  1410. * Minibuffer completion:                Documentation functions.
  1411. * Modeline status:                      Eval and compile functions.
  1412. * Negative prefix:                      Documentation functions.
  1413. * Next definition:                      Source code commands.
  1414. * Next input:                           Command history.
  1415. * Package commands:                     Package Commands.
  1416. * Parenthesis balancing:                Miscellany.
  1417. * Partial completion:                   Completion.
  1418. * Pop in break loop:                    Interrupts.
  1419. * Popper buffers:                       Popper buffers.
  1420. * Previous commands:                    Command history.
  1421. * Previous definition:                  Source code commands.
  1422. * Previous lisp buffer:                 Switching buffers.
  1423. * Raw keyboard mode:                    Keyboard modes.
  1424. * Region commands:                      Eval and compile functions.
  1425. * Reindent lisp:                        Miscellany.
  1426. * Replace lisp:                         Source code commands.
  1427. * Resetting lisp:                       Interrupts.
  1428. * Rigid indentation:                    Miscellany.
  1429. * Running lisp:                         Starting up.
  1430. * Search input:                         Command history.
  1431. * Sending input to lisp:                Eval and compile functions.
  1432. * Set buffer package:                   Package Commands.
  1433. * Set default directory:                Files and directories.
  1434. * Show current package:                 Package Commands.
  1435. * Similar input:                        Command history.
  1436. * Source Code Commands:                 Source code commands.
  1437. * Source modes:                         Source code commands.
  1438. * Starting up lisp:                     Starting up.
  1439. * Status light:                         Eval and compile functions.
  1440. * Supported dialects:                   Starting up.
  1441. * Switching buffers:                    Switching buffers.
  1442. * Symbolic link expansion:              Files and directories.
  1443. * TMC completion:                       Completion.
  1444. * Top-level, return to:                 Interrupts.
  1445. * Tracing defuns:                       Tracing functions.
  1446. * Turning popper off:                   Popper buffers.
  1447. * Uncomment region:                     Miscellany.
  1448. * Untracing defuns:                     Tracing functions.
  1449. * autoload definitions:                 Autoloading.
  1450. * buffers of ILISP:                     Buffers of ILISP.
  1451. * bury output window:                   Popper buffers.
  1452. * defining autoloads:                   Autoloading.
  1453. * epoch popper:                         Popper buffers.
  1454. * features:                             Introduction.
  1455. * grow output window:                   Popper buffers.
  1456. * scrolling output:                     Popper buffers.
  1457.  
  1458. 
  1459. File: ilisp.info,  Node: Key index,  Next: Command index,  Prev: Concept index,  Up: Top
  1460.  
  1461. Key Index
  1462. *********
  1463.  
  1464. * Menu:
  1465.  
  1466. * TAB:                                  Miscellany.
  1467. * C-z !:                                Files and directories.
  1468. * C-z #:                                Keyboard modes.
  1469. * C-z ):                                Miscellany.
  1470. * C-z * 0:                              Batch commands.
  1471. * C-z * c:                              Batch commands.
  1472. * C-z * e:                              Batch commands.
  1473. * C-z * l:                              Batch commands.
  1474. * C-z ;:                                Miscellany.
  1475. * C-z A:                                Documentation functions.
  1476. * C-z C-c:                              Eval and compile functions.
  1477. * C-z C-e:                              Eval and compile functions.
  1478. * C-z C-n:                              Eval and compile functions.
  1479. * C-z C-r:                              Eval and compile functions.
  1480. * C-z C-w:                              Eval and compile functions.
  1481. * C-z D:                                Documentation functions.
  1482. * C-z I:                                Documentation functions.
  1483. * C-z M:                                Macroexpansion.
  1484. * C-z P:                                Package Commands.
  1485. * C-z SPC:                              Batch commands.
  1486. * C-z ^:                                Source code commands.
  1487. * C-z a:                                Documentation functions.
  1488. * C-z b:                                Switching buffers.
  1489. * C-z c:                                Eval and compile functions.
  1490. * C-z d:                                Documentation functions.
  1491. * C-z e:                                Eval and compile functions.
  1492. * C-z g:                                Eval and compile functions.
  1493. * C-z g:                                Interrupts.
  1494. * C-z i:                                Documentation functions.
  1495. * C-z i:                                Documentation functions.
  1496. * C-z k:                                Files and directories.
  1497. * C-z l:                                Files and directories.
  1498. * C-z m:                                Macroexpansion.
  1499. * C-z n:                                Eval and compile functions.
  1500. * C-z p:                                Package Commands.
  1501. * C-z prefix:                           Eval and compile functions.
  1502. * C-z r:                                Eval and compile functions.
  1503. * C-z s:                                Eval and compile functions.
  1504. * C-z t:                                Tracing functions.
  1505. * C-z w:                                Eval and compile functions.
  1506. * C-z z:                                Interrupts.
  1507. * M-TAB:                                Documentation functions.
  1508. * TAB:                                  Documentation functions.
  1509. * C-]:                                  Eval and compile functions.
  1510. * C-c R:                                Command history.
  1511. * C-d:                                  Interrupts.
  1512. * C-g:                                  Interrupts.
  1513. * C-x C-f:                              Files and directories.
  1514. * C-x o:                                Popper buffers.
  1515. * C-z 1:                                Popper buffers.
  1516. * C-z G:                                Popper buffers.
  1517. * C-z v:                                Popper buffers.
  1518. * LFD:                                  Eval and compile functions.
  1519. * M-":                                  Source code commands.
  1520. * M-,:                                  Source code commands.
  1521. * M-.:                                  Source code commands.
  1522. * M-?:                                  Source code commands.
  1523. * M-C-l:                                Switching buffers.
  1524. * M-C-q:                                Miscellany.
  1525. * M-C-x:                                Eval and compile functions.
  1526. * M-N:                                  Command history.
  1527. * M-P:                                  Command history.
  1528. * M-RET:                                Completion.
  1529. * M-TAB:                                Completion.
  1530. * M-`:                                  Source code commands.
  1531. * M-n:                                  Command history.
  1532. * M-p:                                  Command history.
  1533. * M-q:                                  Miscellany.
  1534. * M-s:                                  Command history.
  1535. * M-x io-bridge-ilisp:                  Keyboard modes.
  1536. * M-x lisp-directory:                   Source code commands.
  1537. * M-x set-buffer-package-lisp:          Package Commands.
  1538. * M-x who-calls-lisp:                   Source code commands.
  1539. * RET:                                  Eval and compile functions.
  1540. * ]:                                    Miscellany.
  1541.  
  1542. 
  1543. File: ilisp.info,  Node: Command index,  Next: Variable index,  Prev: Key index,  Up: Top
  1544.  
  1545. Command Index
  1546. *************
  1547.  
  1548. Commands available via `M-x' prefix.
  1549.  
  1550. * Menu:
  1551.  
  1552. * abort-commands-lisp:                  Interrupts.
  1553. * abort-commands-lisp:                  Eval and compile functions.
  1554. * akcl:                                 Starting up.
  1555. * allegro:                              Starting up.
  1556. * arglist-lisp:                         Documentation functions.
  1557. * clear-changes-lisp:                   Batch commands.
  1558. * clisp:                                Starting up.
  1559. * close-all-lisp:                       Miscellany.
  1560. * close-and-send-lisp:                  Eval and compile functions.
  1561. * cmulisp:                              Starting up.
  1562. * comint-msearch-input:                 Command history.
  1563. * comint-msearch-input-matching:        Command history.
  1564. * comint-next-input:                    Command history.
  1565. * comint-previous-input:                Command history.
  1566. * comint-previous-similar-input:        Command history.
  1567. * comint-psearch-input:                 Command history.
  1568. * comment-region-lisp:                  Miscellany.
  1569. * compile-changes-lisp:                 Batch commands.
  1570. * compile-defun-and-go-lisp:            Eval and compile functions.
  1571. * compile-defun-lisp:                   Eval and compile functions.
  1572. * compile-defun-lisp-and-go:            Eval and compile functions.
  1573. * compile-file-lisp:                    Files and directories.
  1574. * compile-region-and-go-lisp:           Eval and compile functions.
  1575. * compile-region-lisp:                  Eval and compile functions.
  1576. * complete:                             Completion.
  1577. * complete-lisp:                        Completion.
  1578. * default-directory-lisp:               Files and directories.
  1579. * defdialect:                           Defining new dialects.
  1580. * delete-char-or-pop-ilisp:             Interrupts.
  1581. * describe-lisp:                        Documentation functions.
  1582. * documentation-lisp:                   Documentation functions.
  1583. * edit-callers-lisp:                    Source code commands.
  1584. * edit-callers-lisp:                    Source code commands.
  1585. * edit-definitions-lisp:                Source code commands.
  1586. * eval-changes-lisp:                    Batch commands.
  1587. * eval-defun-and-go-lisp:               Eval and compile functions.
  1588. * eval-defun-and-go-lisp:               Eval and compile functions.
  1589. * eval-defun-lisp:                      Eval and compile functions.
  1590. * eval-next-sexp-and-go-lisp:           Eval and compile functions.
  1591. * eval-next-sexp-lisp:                  Eval and compile functions.
  1592. * eval-region-and-go-lisp:              Eval and compile functions.
  1593. * eval-region-lisp:                     Eval and compile functions.
  1594. * fi:clman:                             Documentation functions.
  1595. * fi:clman-apropos:                     Documentation functions.
  1596. * find-file-lisp:                       Files and directories.
  1597. * find-unbalanced-lisp:                 Miscellany.
  1598. * ibcl:                                 Starting up.
  1599. * indent-line-ilisp:                    Miscellany.
  1600. * indent-sexp-ilisp:                    Miscellany.
  1601. * inspect-lisp:                         Documentation functions.
  1602. * interrupt-subjob-ilisp:               Interrupts.
  1603. * io-bridge-ilisp:                      Keyboard modes.
  1604. * kcl:                                  Starting up.
  1605. * lisp-directory:                       Source code commands.
  1606. * list-changes-lisp:                    Batch commands.
  1607. * load-file-lisp:                       Files and directories.
  1608. * lucid:                                Starting up.
  1609. * macroexpand-1-lisp:                   Macroexpansion.
  1610. * macroexpand-lisp:                     Macroexpansion.
  1611. * mark-change-lisp:                     Batch commands.
  1612. * newline-and-indent-lisp:              Eval and compile functions.
  1613. * next-caller-lisp:                     Source code commands.
  1614. * next-definition-lisp:                 Source code commands.
  1615. * next-definition-lisp:                 Source code commands.
  1616. * oaklisp:                              Starting up.
  1617. * package-lisp:                         Package Commands.
  1618. * panic-lisp:                           Interrupts.
  1619. * popper-bury-output:                   Popper buffers.
  1620. * popper-grow-output:                   Popper buffers.
  1621. * popper-other-window:                  Popper buffers.
  1622. * popper-scroll-output:                 Popper buffers.
  1623. * previous-buffer-lisp:                 Switching buffers.
  1624. * raw-keys-ilisp:                       Keyboard modes.
  1625. * reindent-lisp:                        Miscellany.
  1626. * replace-lisp:                         Source code commands.
  1627. * reset-ilisp:                          Interrupts.
  1628. * return-ilisp:                         Eval and compile functions.
  1629. * run-ilisp:                            Starting up.
  1630. * scheme:                               Starting up.
  1631. * search-lisp:                          Source code commands.
  1632. * set-buffer-package-lisp:              Package Commands.
  1633. * set-package-lisp:                     Package Commands.
  1634. * setup-ilisp:                          Defining new dialects.
  1635. * status-lisp:                          Eval and compile functions.
  1636. * switch-to-lisp:                       Switching buffers.
  1637. * trace-defun-lisp:                     Tracing functions.
  1638. * who-calls-lisp:                       Source code commands.
  1639.  
  1640. 
  1641. File: ilisp.info,  Node: Variable index,  Next: Function index,  Prev: Command index,  Up: Top
  1642.  
  1643. Variable Index
  1644. **************
  1645.  
  1646. Variables and hooks of ILISP.
  1647.  
  1648. * Menu:
  1649.  
  1650. * *record-source-files*:                Source code commands.
  1651. * DIALECT-hook:                         Customization.
  1652. * auto-mode-alist:                      Source code commands.
  1653. * comint-always-scroll:                 Popper buffers.
  1654. * comint-mode-hook:                     Customization.
  1655. * default-directory:                    Files and directories.
  1656. * ilisp-defvar-regexp:                  Eval and compile functions.
  1657. * ilisp-filter-length:                  Command history.
  1658. * ilisp-filter-length:                  Customization.
  1659. * ilisp-filter-regexp:                  Customization.
  1660. * ilisp-filter-regexp:                  Command history.
  1661. * ilisp-init-binary-command:            Files of ILISP.
  1662. * ilisp-init-binary-extension:          Files of ILISP.
  1663. * ilisp-init-hook:                      Customization.
  1664. * ilisp-init-hook:                      Customization.
  1665. * ilisp-load-hook:                      Customization.
  1666. * ilisp-load-inits:                     Files of ILISP.
  1667. * ilisp-locator:                        Source code commands.
  1668. * ilisp-mode-hook:                      Customization.
  1669. * ilisp-mode-hook:                      Customization.
  1670. * ilisp-motd:                           Customization.
  1671. * ilisp-other-prompt:                   Customization.
  1672. * ilisp-package-regexp:                 Package Commands.
  1673. * ilisp-prefix:                         Customization.
  1674. * ilisp-prefix:                         Eval and compile functions.
  1675. * ilisp-prefix-match:                   Completion.
  1676. * ilisp-prefix-match:                   Customization.
  1677. * ilisp-program:                        Customization.
  1678. * ilisp-program:                        Files of ILISP.
  1679. * ilisp-raw-echo:                       Keyboard modes.
  1680. * ilisp-site-hook:                      Files of ILISP.
  1681. * ilisp-site-hook:                      Customization.
  1682. * lisp-edit-files:                      Source code commands.
  1683. * lisp-no-popper:                       Popper buffers.
  1684. * lisp-no-popper:                       Customization.
  1685. * lisp-show-status:                     Eval and compile functions.
  1686. * lisp-show-status:                     Customization.
  1687. * lisp-source-modes:                    Source code commands.
  1688. * lisp-wait-p:                          Customization.
  1689. * lisp-wait-p:                          Interrupts.
  1690. * lisp-wait-p:                          Eval and compile functions.
  1691. * pop-up-windows:                       Switching buffers.
  1692. * popper-buffers-to-skip:               Popper buffers.
  1693. * popper-pop-buffers:                   Popper buffers.
  1694. * popper-pop-buffers:                   Popper buffers.
  1695. * popper-screen-properties:             Popper buffers.
  1696.  
  1697. 
  1698. File: ilisp.info,  Node: Function index,  Prev: Variable index,  Up: Top
  1699.  
  1700. Function Index
  1701. **************
  1702.  
  1703. Internal functions of ILISP which can be used to write new commands.
  1704.  
  1705. * Menu:
  1706.  
  1707. * compile-region-lisp:                  Writing new commands.
  1708. * deflocal:                             Writing new commands.
  1709. * eval-region-lisp:                     Writing new commands.
  1710. * ilisp-compile-inits:                  Files of ILISP.
  1711. * ilisp-completing-read:                Writing new commands.
  1712. * ilisp-dialect:                        Writing new commands.
  1713. * ilisp-package-command:                Package Commands.
  1714. * ilisp-read:                           Writing new commands.
  1715. * ilisp-read-symbol:                    Writing new commands.
  1716. * ilisp-send:                           Writing new commands.
  1717. * lisp-buffer-symbol:                   Writing new commands.
  1718. * lisp-def-name:                        Writing new commands.
  1719. * lisp-function-name:                   Writing new commands.
  1720. * lisp-previous-sexp:                   Writing new commands.
  1721. * lisp-previous-symbol:                 Writing new commands.
  1722. * lisp-string-to-symbol:                Writing new commands.
  1723. * lisp-symbol:                          Writing new commands.
  1724. * lisp-symbol-delimiter:                Writing new commands.
  1725. * lisp-symbol-name:                     Writing new commands.
  1726. * lisp-symbol-package:                  Writing new commands.
  1727. * lisp-symbol-to-string:                Writing new commands.
  1728.  
  1729.  
  1730. 
  1731. Tag Table:
  1732. Node: Top883
  1733. Node: Distribution1854
  1734. Node: FTP directions2882
  1735. Node: Acknowledgements3523
  1736. Node: Introduction4467
  1737. Node: Installation6151
  1738. Node: Files of ILISP6663
  1739. Node: Autoloading9527
  1740. Node: Starting up12856
  1741. Node: Buffers of ILISP14087
  1742. Node: Popper buffers15573
  1743. Node: Switching buffers17597
  1744. Node: ILISP Commands18238
  1745. Node: Eval and compile functions18997
  1746. Node: Documentation functions23300
  1747. Node: Macroexpansion25509
  1748. Node: Tracing functions25951
  1749. Node: Package Commands26311
  1750. Node: Source code commands27362
  1751. Node: Batch commands31310
  1752. Node: Files and directories32612
  1753. Node: Keyboard modes33928
  1754. Node: Interrupts35092
  1755. Node: Command history36965
  1756. Node: Completion38133
  1757. Node: Miscellany39948
  1758. Node: Customization41198
  1759. Node: Dialects42817
  1760. Node: Defining new dialects43458
  1761. Node: Writing new commands44030
  1762. Node: Concept index45338
  1763. Node: Key index54453
  1764. Node: Command index59110
  1765. Node: Variable index64451
  1766. Node: Function index67263
  1767. 
  1768. End Tag Table
  1769.